package;

import haxe.io.Eof;
import sys.io.File;
import sys.io.FileInput;
import sys.io.FileOutput;
import flixel.addons.ui.FlxInputText;
import flixel.addons.ui.FlxUIDropDownMenu;
import flixel.effects.particles.FlxEmitter;
import flixel.ui.FlxButton;
import flixel.FlxBasic;
import flixel.FlxG;
import flixel.FlxSprite;
import flixel.FlxState;
import flixel.group.FlxTypedGroup;
import flixel.util.FlxColor;
import flixel.util.FlxPoint;

/**
 * Estado de juego destinado a la edicion de niveles para su archivado
 * y posterior uso, los archivos de niveles seran por ahora archivos de texto (.txt).
 * Dentro de los archivos de texto se encontra una matriz con caracteres que representan
 * cada tipo de bloque o lugar vacio "".
 */ 
 
class EditorState extends FlxState
{
	/**
	 * Function that is called up when to state is created to set it up. 
	 */
	
//----Imagenes extra en el PlayState----

	private var _background:FlxSprite;
	 	
//---------Necesarias para Crear un Nivel o Cargarlo-------------

	private var _tipo:String;
	public var _Matriz:String; 

	private var _bloque:Bloques;
	
	private var _plataforma:Plataformas;
	
	private var _point:FlxPoint;
	
	private var _jugador:Jugador;
	
	private var _jugadorCreado:Bool = false;      //No se puede poner mas de 1 jugador 
	
	//----------Groups-----------------------------------------
		private var _bloques:FlxTypedGroup<Bloques>;
		private var _plataformas:FlxTypedGroup<Plataformas>;
		private var _botones:FlxTypedGroup<FlxButton>; 
		public var _emisores:FlxTypedGroup<FlxEmitter>;
		public var _jugadores:FlxTypedGroup<Jugador>;
		public var _indicaReceptores:FlxTypedGroup<FlxSprite>;
	
//---------Para la Interfaz Grafica del Editor--------------------
	
	//----Editor Tutorial-----------------
	private var _editorTutorial:FlxSprite;
	
	//----Botones de Bloques--------------
	private var _wallButton:FlxButton;
	private var _characterButton:FlxButton;
	private var _emitterButton:FlxButton;
	private var _receptorButton:FlxButton;
	private var _turnTableButton:FlxButton;
	
	//----Otros Botones-------------------
	private var _clearButton:FlxButton;
	private var _saveButton:FlxButton;
	private var _testButton:FlxButton;
	
	//----Ventana save/open------------------------

		//----Botones------------------------------
		private var _saveWindow:FlxButton;
		private var _openWindow:FlxButton;
		private var _cancelWindow:FlxButton;
		
		//----Escritura----------------------------
		private var _windowText:FlxInputText;
		
		//-----Grafico-----------------------------
		private var _ventanaGrafico1:FlxSprite; 
	
//-------Necesario para la Edicion--------------------------- 

	private var _seguir:Bool = false;
	private var _recienCreado:Bool = true;
	public var _Texto:String;

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------

	override public function create():Void
	{	
		super.create();

//----Imagenes o animaciones extras en el PlayState-------

		_background = new FlxSprite(0, 0);
		_background.loadGraphic("assets/images/FondoV1.0_600x480_1Frame.png", false, 600, 480);
		add(_background);                                                                                        //Debe estar al fondo de toodooo
				
//-----Nos sirve para ubicar las coordenadas del mouse---------------

		_point = new FlxPoint(0, 0);

//-----Es un Sprite gigante que contiene las instrucciones del editor, tanto como los Shortcuts del mismo-----

		_editorTutorial = new FlxSprite(0, 0);
		_editorTutorial.loadGraphic("assets/images/EditorManualV1.6_640x884_1Frame.png", false, 640, 884);
		_editorTutorial.visible = true;

//---------Groups------------------------------------------
{
		_bloques = new FlxTypedGroup<Bloques>();
		_plataformas = new FlxTypedGroup<Plataformas>();
		_botones = new FlxTypedGroup<FlxButton>();
		_jugadores = new FlxTypedGroup<Jugador>();
		_emisores = new FlxTypedGroup<FlxEmitter>();
		_indicaReceptores = new FlxTypedGroup<FlxSprite>();
}
//-------En donde se Escribe el nombre del archivo a guardar o a cargar------------------------------
{		
		_windowText = new FlxInputText(150, 100, 300, "", 12, FlxColor.BLACK, FlxColor.WHITE, true);
		_windowText.makeGraphic(310, 50, FlxColor.BROWN);
		_windowText.exists = false;
		
		//-----Boton de Guardar en la ventana de save/open-----
		_saveWindow = new FlxButton(155, 130, "Save", GuardarBoton);
		_saveWindow.makeGraphic(80, 30, FlxColor.SILVER);
		_saveWindow.exists = false;
		_botones.add(_saveWindow);
		
		//-----Boton de Abrir archivo en la ventana de save/open-----
		_openWindow = new FlxButton(240, 130, "Open", CargarNivel);
		_openWindow.makeGraphic(80, 30, FlxColor.SILVER);
		_openWindow.exists = false;
		_botones.add(_openWindow);
		
		//-----Boton de Cancelar en la ventana de save/open-----
		_cancelWindow = new FlxButton(325, 130, "Cancel", CancelarGuardada);
		_cancelWindow.makeGraphic(80, 30, FlxColor.SILVER);
		_cancelWindow.exists = false;
		_botones.add(_cancelWindow);
		
		//-----Grafico de fondo de la ventana de save/open-----
		_ventanaGrafico1 = new FlxSprite(145, 95);
		_ventanaGrafico1.makeGraphic(310, 90, FlxColor.CYAN);
		_ventanaGrafico1.exists = false;
}
//---------Botones que usa el usuario para sacar bloques--------------------
{
		//----Boton de Pared--------
		_wallButton = new FlxButton(610, 15,"Wall (W)",CrearPared);
		_wallButton.makeGraphic(30, 30, FlxColor.BLUE);
		_botones.add(_wallButton);
		
		//----Boton de Emisor--------
		_emitterButton = new FlxButton(610, 75,"Emitt (E)",CrearEmisor);
		_emitterButton.makeGraphic(30, 30, FlxColor.GREEN);
		_botones.add(_emitterButton);
		
		//----Boton de Receptor--------
		_receptorButton = new FlxButton(610, 135,"Rece (R)",CrearReceptor);
		_receptorButton.makeGraphic(30, 30, FlxColor.HOT_PINK);
		_botones.add(_receptorButton);
		
		//----Boton de Plataforma Giratoria--------
		_turnTableButton = new FlxButton(610, 195,"Turn (T)",CrearGiratoria);
		_turnTableButton.makeGraphic(30, 30, FlxColor.GRAY);
		_botones.add(_turnTableButton);
}		
//---------Botones para el manejo del Editor------------------------------
{
		//----Limpiar pantalla, borrando todos los bloques--------
		_clearButton = new FlxButton(610, 315,"Clear (SB)",Clear);
		_clearButton.makeGraphic(30, 30, FlxColor.WHITE);
		_botones.add(_clearButton);
		
		//----Boton para ubicar al Personaje-------------------------------
		_characterButton = new FlxButton(610, 255,"Char (C)",CrearJugador);
		_characterButton.makeGraphic(30, 30, FlxColor.RED);
		_botones.add(_characterButton);
		
		//----Boton para testear el Nivel----------------------
		_testButton = new FlxButton(610, 435,"Test",TestLevel);
		_testButton.makeGraphic(30, 30, FlxColor.WHITE);
		_botones.add(_testButton);
		
		//----Boton para Abrir la ventana de Save/Open-------------
		_saveButton = new FlxButton(610, 375,"Save Open",AbrirS_O);
		_saveButton.makeGraphic(30, 30, FlxColor.YELLOW);
		_botones.add(_saveButton);
}		
//------Se utiliza para crear el mapa que estabas testeando y que no se borre todo y tengas que reconstruirlo---

		if (Reg.Testing)
		{
			CrearMapa("");
		}

//----------------Lista de adds()---------	
		{
		add(_plataformas);
		add(_jugadores);	
		add(_emisores);
		add(_bloques);
		add(_indicaReceptores);
		add(_ventanaGrafico1);
		add(_windowText);
		add(_botones);
		add(_editorTutorial);
		}
	}
	
	/**
	 * Function that is called when this state is destroyed - you might want to 
	 * consider setting all objects this state uses to null to help garbage collection.
	 */

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	override public function destroy():Void
	{
		super.destroy();
	}

	/**
	 * Function that is called once every frame.
	 */
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	override public function update():Void
	{
		super.update();
		
//------Todo lo relacionado al Tutorial de Editor esta en este bloque----------------------
		{
		if (Reg._desactivarTutorial)
		{
			_editorTutorial.visible = false;
		}
		
		if (FlxG.keys.justPressed.Q)
		{
			Reg._desactivarTutorial = !Reg._desactivarTutorial;
		}
		
		if (FlxG.keys.justPressed.ENTER)
		{
			_editorTutorial.visible = !_editorTutorial.visible;
			_editorTutorial.y = 0;
		}
		
		_editorTutorial.velocity.x = 0;
		_editorTutorial.velocity.y = 0;
		
		if ((FlxG.keys.pressed.UP || FlxG.mouse.wheel < 0) && _editorTutorial.visible && _editorTutorial.y > FlxG.height - 884)
		{	
			_editorTutorial.velocity.y = -300;
		}
		else
		{
			if ((FlxG.keys.pressed.DOWN || FlxG.mouse.wheel > 0) && _editorTutorial.visible && _editorTutorial.y < 0)
			{
				_editorTutorial.velocity.y = 300;
			}
		}
		}
//------------------Todos los Shortcuts----------------------------------
		{
		//--Para que guarde cuando apretamos Enter y esta la ventana Save/Open abierta----
		if (FlxG.keys.justPressed.ENTER && _windowText.exists && !_editorTutorial.visible)
		{
			CrearPared();
		}
		
		if (FlxG.keys.justPressed.W && _windowText.exists == false)
		{
			CrearPared();
		}
		
		if (FlxG.keys.justPressed.B && _windowText.exists == false)
		{
			CrearRompible();
		}
		
		if (FlxG.keys.justPressed.E && _windowText.exists == false)
		{
			CrearEmisor();
		}
		
		if (FlxG.keys.justPressed.R && _windowText.exists == false)
		{
			CrearReceptor();
		}
		 
		if (FlxG.keys.justPressed.T && _windowText.exists == false)
		{
			CrearGiratoria();
		}
		
		if (FlxG.keys.justPressed.C && _windowText.exists == false)
		{
			CrearJugador();
		}
		
		if (FlxG.keys.justPressed.SPACE && _windowText.exists == false)
		{
			Clear();
		}
		
		if (FlxG.keys.justPressed.S && _windowText.exists == false)
		{
			AbrirS_O();
		}
		}
//---------Click derecho para Borrar, Aca-------------------------
		{
		if (FlxG.mouse.justPressedRight && _recienCreado)
		{
			for (bloq in _bloques)
			{
				_point.x = FlxG.mouse.x;
				_point.y = FlxG.mouse.y;
				
				if (bloq.overlapsPoint(_point)) 
				{
					if (bloq._tipo == "Emisor")
					{	
						Reg.E_Descart.push(bloq._color); //Cuando sacamos el Emisor lo ponemos en la cola de colores descartados
						bloq._emitter.destroy();
					}
					if (bloq._tipo == "Receptor")
					{	
						Reg.R_Descart.push(bloq._color); //Cuando sacamos el Receptor lo ponemos en la cola de colores descartados
						bloq._indicador.destroy();
					}
					bloq.destroy();
					bloq.x = -100;
					bloq.y = -100;
				}
			}
		}
		
		if (FlxG.mouse.justPressedRight && _recienCreado)
		{
			for (plat in _plataformas)
			{
				_point.x = FlxG.mouse.x;
				_point.y = FlxG.mouse.y;
				
				if (plat.overlapsPoint(_point)) 
				{
					plat.destroy();
					plat.x = -100;
					plat.y = -100;
				}
			}
		}
		
		if (FlxG.mouse.justPressedRight && _recienCreado)
		{
			for (jug in _jugadores)
			{
				_point.x = FlxG.mouse.x;
				_point.y = FlxG.mouse.y;
				
				if (jug.overlapsPoint(_point)) 
				{
					jug.destroy();
					_jugadorCreado = false;
					jug.x = -100;
					jug.y = -100;
				}
			}
		}
		}
//------Click izquierdo en bloque para girar, Aca-------------------------
		{
		if (FlxG.mouse.justPressed && _recienCreado)
		{
			for (bloq in _bloques)
			{
				_point.x = FlxG.mouse.x;
				_point.y = FlxG.mouse.y;
				
				if (bloq.overlapsPoint(_point) && bloq._tipo != "Pared") 
				{
					bloq._angulo += Math.PI / 2;
					bloq._direccion++;
				}
			}
		}
		 	
		if (FlxG.mouse.justPressed && _recienCreado)
		{
			for (gir in _plataformas)
			{
				_point.x = FlxG.mouse.x;
				_point.y = FlxG.mouse.y;
				
				if (gir.overlapsPoint(_point)) 
				{
					gir._sentido++;
				}
			}
		}
		}
//------Todo lo que tenga que ver con poner un bloque luego de haber seleccionado cual-------
	
		PosicionarBloque();
		
//------Colicciones entre Fotones y Bloques, para tener una idea de como queda el Nivel------
		
		FlxG.overlap(_emisores, _bloques, Reg.opacar);
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function PosicionarBloque():Void //Se utiliza para posicionar los bloques a donde el usuario haga click
	{
		var _auxColor:Int = 0;
		
		if (_seguir)
		{
			if (_tipo == "Pared" || _tipo == "Emisor" || _tipo == "Receptor" || _tipo == "Rompible")
			{				
				if (_recienCreado)
				{
					if (_tipo != "Emisor" && _tipo != "Receptor")
					{
						_bloque = new Bloques(10, 10, false, _tipo, 0, 0);
						_bloques.add(_bloque);
					}
					
					if (_tipo == "Emisor")
					{
						if (Reg.E_Descart.length == 0)		   //Si la cola no tiene ningun elemento entonces usamos los de la pila
						{
							_auxColor = Reg.E_Colors.pop();    //Sacamos el elemento mas alto de la pila de Colores para Emisores
							trace(_auxColor);
						}
						else
						{
							_auxColor = Reg.E_Descart.shift(); //Si la cola tiene elementos usamos esos
						}
						_bloque = new Bloques(10, 10, false, _tipo, 0, _auxColor);
						_bloques.add(_bloque);
						_emisores.add(_bloque._emitter);
					}
					
					if (_tipo == "Receptor")
					{	
						if (Reg.R_Descart.length == 0)		   //Si la cola no tiene ningun elemento entonces usamos los de la pila
						{
							_auxColor = Reg.R_Colors.pop();    //Sacamos el elemento mas alto de la pila de Colores para Emisores
						}
						else
						{
							_auxColor = Reg.R_Descart.shift(); //Si la cola tiene elementos usamos esos
						}
						_bloque = new Bloques(10, 10, false, _tipo, 0, _auxColor);
						_bloques.add(_bloque);
						_indicaReceptores.add(_bloque._indicador);
					}
				}
				
				_recienCreado = false;
				_bloque.x = FlxG.mouse.x - 30;
				_bloque.y = FlxG.mouse.y - 30;
				
				if (FlxG.mouse.justPressed)
				{
					for (i in  0 ... 10)
					{
						for (j in  0 ... 8)
						{
							if ((i * Reg._altoB < FlxG.mouse.x && FlxG.mouse.x < (i + 1) * Reg._altoB) && (j * Reg._altoB < FlxG.mouse.y && FlxG.mouse.y < (j + 1) * Reg._altoB))
							{
								_bloque.x = i * Reg._altoB;
								_bloque.y = j * Reg._altoB;
							
								_seguir = false;
								_recienCreado = true;
							}
						}
					}
				}	
			}
			
			if (_tipo == "Giratoria")
			{				
				if (_recienCreado)
				{
					_plataforma = new Plataformas(10, 10, _tipo, 0);
					_plataformas.add(_plataforma);
				}
				
				_recienCreado = false;
				_plataforma.x = FlxG.mouse.x - 30;
				_plataforma.y = FlxG.mouse.y - 30;
				
				if (FlxG.mouse.justPressed)
				{
					for (i in  0 ... 10)
					{
						for (j in  0 ... 8)
						{
							if ((i * 60 < FlxG.mouse.x && FlxG.mouse.x < (i + 1) * 60) && (j * 60 < FlxG.mouse.y && FlxG.mouse.y < (j + 1) * 60))
							{
								_plataforma.x = i * 60;
								_plataforma.y = j * 60;
							
								_seguir = false;
								_recienCreado = true;
							}
						}
					}
				}	
			}
			if (_tipo == "Jugador" && !_jugadorCreado)
			{				
				if (_recienCreado)
				{
					_jugador = new Jugador(10, 10);
					_jugadores.add(_jugador);
				}
				
				_recienCreado = false;
				
				_jugador.x = FlxG.mouse.x - 7;
				_jugador.y = FlxG.mouse.y - 7;
				
				if (FlxG.mouse.justPressed)
				{
					for (i in  0 ... 10)
					{
						for (j in  0 ... 8)
						{
							if ((i * Reg._altoB < FlxG.mouse.x && FlxG.mouse.x < (i + 1) * Reg._altoB) && (j * Reg._altoB < FlxG.mouse.y && FlxG.mouse.y < (j + 1) * Reg._altoB))
							{
								_jugador.x = i * Reg._altoB + Reg._altoB/4;
								_jugador.y = j * Reg._altoB + Reg._altoB/4;
							
								_seguir = false;
								_recienCreado = true;
								
								_jugadorCreado = true;
							}
						}
					}
				}
			}
		}
	}
	
//---------------------------------------------------------------------------
//--TODAS LAS FUNCIONES QUE TIENEN QUE VER CON CREEAR UN OBJETO ESTAN EN ESTE BLOQUE
//---------------------------------------------------------------------------
	
	public function CrearPared():Void //Selecciona para crear una Pared
	{
		_seguir = true;
		_tipo = "Pared";
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function CrearEmisor():Void //Selecciona para crear un Emisor
	{
		_seguir = true;
		_tipo = "Emisor";
	}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	public function CrearRompible():Void //Selecciona para crear un Bloque Rompible
	{
		_seguir = true;
		_tipo = "Rompible";
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function CrearReceptor():Void //Selecciona para crear un Receptor
	{
		_seguir = true;
		_tipo = "Receptor";
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function CrearGiratoria():Void //Selecciona para crear una Plataforma Giratoria
	{
		_seguir = true;
		_tipo = "Giratoria";
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function CrearJugador():Void //Selecciona para Posicionar al Jugador
	{
		_seguir = true;
		_tipo = "Jugador";
	}
	
	
//---------------------------------------------------------------------------
//--TODAS LAS FUNCIONES QUE SE ACTIVAN DESDE UN BOTON ESTAN EN ESTE BLOQUE
//---------------------------------------------------------------------------
	
	public function Clear():Void //"Limpia la pantalla" en realidad reinicia el Editor
	{
		Reg.E_Colors = [9, 8, 7, 6, 5, 4, 3, 2, 1];
		Reg.E_Descart = [];
		Reg.R_Colors = [9, 8, 7, 6, 5, 4, 3, 2, 1];
		Reg.R_Descart = [];
		FlxG.resetState();
	}
		
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	private function TestLevel():Void //Genera un Nivel dentro del programa, va al PlayState y lo crea alli
	{
		GuardarArchivo("default.txt");
		Reg.Testing = true;
		FlxG.switchState(new PlayState());
	}
		
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	private function AbrirS_O():Void //Abre la ventana de Save/Open
	{
		_windowText.exists = true;
		_saveWindow.exists = true;
		_openWindow.exists = true;
		_cancelWindow.exists = true;
		_ventanaGrafico1.exists = true;
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	private function GuardarBoton():Void //Cierra la ventana de Save/Open y luego llama a GuardarArchivo (la cual realmente lo guarda) 
	{
		_windowText.exists = false;
		_saveWindow.exists = false;
		_openWindow.exists = false;
		_cancelWindow.exists = false;
		_ventanaGrafico1.exists = false;
		GuardarArchivo(_windowText.text + ".txt");
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	private function CargarNivel():Void //Cierra la ventana de Save/Open y luego crea el Nivel con el nombre especificado
	{
		_windowText.exists = false;
		_saveWindow.exists = false;
		_openWindow.exists = false;
		_cancelWindow.exists = false;
		_ventanaGrafico1.exists = false;
		CrearMapa(_windowText.text);
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	private function CancelarGuardada():Void //Cierra la ventana de Save/Open sin hacer nada
	{
		_windowText.exists = false;
		_saveWindow.exists = false;
		_openWindow.exists = false;
		_cancelWindow.exists = false;
		_ventanaGrafico1.exists = false;
	}
		
//---------------------------------------------------------------------------
//--TODAS LAS FUNCIONES QUE UTILIZAN EL MANEJO DE ARCHIVOS ESTAN EN ESTE BLOQUE
//---------------------------------------------------------------------------
	
	private function GuardarArchivo(name:String):Void //Escribe el archivo con el nombre especificado (escrito en la ventana S/O), con todos los datos para luego poder cargarlo
	{
		var archivoOut = File.write("assets/data/" + name, false);
		
		var valor:Int;
		
		for (i in 0...8)
		{
			for (j in 0...10)
			{
				_point.x = j * Reg._altoB + Reg._altoB/2;
				_point.y = i * Reg._altoB + Reg._altoB/2;
				
				for (block in _bloques)
				{
					if (block.overlapsPoint(_point))
					{
						if (block._tipo == "Pared")
						{
							archivoOut.writeString("P");
							Reg.DefaultLevel += "P";
						}
						
						if (block._tipo == "Rompible")
						{
							archivoOut.writeString("B");
							Reg.DefaultLevel += "B";
						}
						
						if (block._tipo == "Emisor")
						{
							archivoOut.writeString("E");
							Reg.DefaultLevel += "E";
							
							valor = block._direccion;
							
							archivoOut.writeString(Std.string(valor));
							Reg.DefaultLevel += valor;
							
							archivoOut.writeString(Std.string(block._color));
							Reg.DefaultLevel += block._color;
						}
						
						if (block._tipo == "Receptor")
						{
							archivoOut.writeString("R");
							Reg.DefaultLevel += "R";
							
							valor = block._direccion;
							
							archivoOut.writeString(Std.string(valor));
							Reg.DefaultLevel += valor;
							
							archivoOut.writeString(Std.string(block._color));
							Reg.DefaultLevel += block._color;
						}
					}	
				}
				
				for (plataform in _plataformas)
				{
					if (plataform.overlapsPoint(_point))
					{
						if (plataform._tipo == "Giratoria")
						{
							archivoOut.writeString("G");
							Reg.DefaultLevel += "G";
							
							valor = plataform._sentido;
							
							archivoOut.writeString(Std.string(valor));
							Reg.DefaultLevel += valor;
						}
					}	
				}
				
				for (juga in _jugadores)
				{
					if (juga.overlapsPoint(_point))
					{
						archivoOut.writeString("J");
						Reg.DefaultLevel += "J";
					}	
				}
				archivoOut.writeString(",");
				Reg.DefaultLevel += ",";
			}
			
			archivoOut.writeString("\n");
			Reg.DefaultLevel += "\n";
		}
		
		archivoOut.writeString("-");
		Reg.DefaultLevel += "-";
		
		archivoOut.close();
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function CrearMapa(name:String):Void //Crea todo el mapa con el nombre del String que se pasa como Argumento [Debe estar en un archivo .txt en la carpeta /assets/data (No agregarle el .txt al nombre)]
	{											//Se utiliza cuando se carga el mapa
		var i:Int = 0;
		var posX:Int = 0;
		var posY:Int = 0;
		
		var direccion:Int;
		
		if (Reg.Testing)
		{
			_Matriz = Reg.DefaultLevel;
		}
		else
		{
			_Matriz = File.getContent("assets/data/" + name + ".txt");
		}
		
		Reg.DefaultLevel = "";
		
		while(_Matriz.charAt(i) != '-')
		{
			if (_Matriz.charAt(i) == 'P') //Pared
			{
				_bloque = new Bloques(posX * Reg._altoB, posY * Reg._altoB, false, "Pared",0,0);
				_bloques.add(_bloque);
			}
				
			if (_Matriz.charAt(i) == 'B') //Rompible (B de Breakable)
			{
				_bloque = new Bloques(posX * Reg._altoB, posY * Reg._altoB, true, "Rompible",0,0);
				_bloques.add(_bloque);
			}
			
			if(_Matriz.charAt(i) == '\n') //Enter
			{
				posY++;
				posX = 0;
			}
			
			if(_Matriz.charAt(i) == ',') //Espacio
			{
				posX++;	
			}
			
			if (_Matriz.charAt(i) == 'J') //Jugador
			{
				_jugador = new Jugador(posX * Reg._altoB + 15, posY * Reg._altoB + 15);
				_jugadores.add(_jugador);
				_jugadorCreado = true;
			}
			
			if(_Matriz.charAt(i) == 'E') //Emisor , Direccion, Color (R:0,B:1,G:2)
			{
				i++;   //Porque se escribe, por ej "-E1R-" y se lee que es un Emisor con direccion 1, color Rojo
				
				direccion = Std.parseInt(_Matriz.charAt(i));
				
				i++;
				
				_bloque = new Bloques(posX * Reg._altoB, posY * Reg._altoB, true, "Emisor",direccion,Std.parseInt(_Matriz.charAt(i)));
				_bloques.add(_bloque);
				_emisores.add(_bloque._emitter);
				
			}
			
			 
			if(_Matriz.charAt(i) == 'R')  //Receptor , Direccion, Color
			{
				i++;   //Porque se escribe, por ej "-R12-" y se lee que es un Receptor con direccion 1 y color 2
				
				direccion = Std.parseInt(_Matriz.charAt(i));
				
				i++;
					
				_bloque = new Bloques(posX * Reg._altoB, posY * Reg._altoB, false, "Receptor",direccion,Std.parseInt(_Matriz.charAt(i)));
				_bloques.add(_bloque);
				_indicaReceptores.add(_bloque._indicador);
			}
			
			
			if(_Matriz.charAt(i) == 'G')  //Giratoria , Sentido (0:Antihorario, 1:Horario)
			{
				i++;   //Porque se escribe, por ej "-G0-" y se lee que es una plataforma Giratoria de sentido Antihorario
				_plataforma = new Plataformas(posX * Reg._altoP, posY * Reg._altoP,"Giratoria",Std.parseInt(_Matriz.charAt(i)));
				_plataformas.add(_plataforma);
			}
		 	i++;
		}
		
		Reg.Testing = false;
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

}